home *** CD-ROM | disk | FTP | other *** search
/ MacTech 1 to 12 / MacTech-vol-1-12.toast / Source / MacTech® Magazine / Volume 05 - 1989 / 05.10 Oct 89 / XCMDs Source < prev   
Encoding:
Text File  |  1989-09-12  |  5.3 KB  |  246 lines  |  [TEXT/MACA]
  1.  
  2. /**********************************/
  3. /* File: FileCopy.c                */
  4. /*                                */
  5. /* param0 = file reference num        */
  6. /*         ( file is open    )    */
  7. /* ----------------------------    */
  8. /*                                */
  9. /* IN:                            */
  10. /*    params[0]    = name of input    */
  11. /*    params[1]    = wdid of input    */
  12. /*    params[2]     = name of output    */
  13. /*    params[3]     = wdid of output    */
  14. /**********************************/
  15.  
  16. #include    <MacTypes.h>
  17. #include    <OSUtil.h>
  18. #include    <MemoryMgr.h>
  19. #include    <FileMgr.h>
  20. #include    <ResourceMgr.h>
  21. #include    <pascal.h>
  22. #include    <string.h>
  23. #include      "HyperXCMD.h"
  24. #include    "HyperUtils.h"
  25.  
  26. pascal void main( paramPtr )
  27.     XCmdBlockPtr    paramPtr;
  28. /*****************************
  29. *    params[0]    = name of input    
  30. *    params[1]    = wdid of input    
  31. *    params[2]     = name of output
  32. *    params[3]     = wdid of output
  33. *
  34. *****************************/
  35. {
  36.     OSErr        err;
  37.     short        inWD;
  38.     short        outWD;
  39.     long        temp;
  40.     Str31        errCode;
  41.     char        inFile[256];
  42.     char        outFile[256];
  43.  
  44.     paramPtr->returnValue = 0L;
  45.     
  46.     /*** (1) Get input parameters         ***/
  47.     HLock( paramPtr->params[0] );
  48.     ZeroToPas( paramPtr, *(paramPtr->params[0]), &inFile );
  49.     HUnlock( paramPtr->params[0] );
  50.     
  51.     inWD = (short)paramtoNum( paramPtr, 1 );
  52.  
  53.     HLock( paramPtr->params[2] );
  54.     ZeroToPas( paramPtr, *(paramPtr->params[2]), &outFile );
  55.     HUnlock( paramPtr->params[2] );
  56.     
  57.     outWD = (short)paramtoNum( paramPtr, 3 );
  58.     
  59.     temp = (long)CopyFile( inFile, inWD, outFile, outWD );
  60.  
  61.  
  62.     /*** Flush the output volume        ***/
  63.     err = FlushVol( 0L, 0 );
  64.     
  65.     NumToStr( paramPtr, temp, &errCode );
  66.     paramPtr->returnValue = PasToZero( paramPtr, &errCode );
  67. }
  68.  
  69. LISTING 1: CopyFile XCMD.
  70.  
  71.  
  72.  
  73. OSErr    CopyFork( inref, outref, siz )
  74.     short    inref;
  75.     short    outref;
  76.     long    siz;
  77. /*****************************
  78. * Given that the caller has opened
  79. * a fork and passed you the names of 
  80. * the input, copy the number of bytes
  81. * from the input fork to the output 
  82. * fork.
  83. *
  84. * The input mark should be set to 
  85. * start of fork.
  86. *
  87. * We use a "semi-smart" algorithm
  88. * to do the copy.  If the entire
  89. * fork can be copied, we try doing 
  90. * that, otherwise, we keep dividing
  91. * the size by two until we get enough
  92. * room to read some data in.
  93. *
  94. ******************************/
  95. {
  96.     OSErr    rd_err        = noErr;
  97.     OSErr    wrt_err        = noErr;
  98.     long        rd_len;    /*** actual bytes read ***/
  99.     Ptr        inbuf;
  100.     
  101.     /*** make sure that the size is even ***/
  102.     if( siz % 2 )
  103.         ++siz;
  104.         
  105.     if( siz > 0 ){
  106.         do{
  107.             inbuf = NewPtr( siz );
  108.             if( !inbuf )
  109.                 siz = ( siz >> 1 );
  110.                 
  111.         }while( !inbuf );
  112.     
  113.     /*** inbuf is the buffer that we     ***/
  114.     /*** read the data into. If not     ***/
  115.     /*** allocated, don't attempt to do    ***/
  116.     /*** the read                     ***/
  117.         if( inbuf ){
  118.             do{
  119.                 rd_len = siz;
  120.                 rd_err = FSRead( inref, &rd_len, inbuf );
  121.                 wrt_err= FSWrite( outref, &rd_len, inbuf );
  122.             }while( !rd_err && !wrt_err );
  123.             
  124.             DisposPtr( inbuf );
  125.         }
  126.     }
  127.     return( wrt_err );
  128. }
  129.  
  130.  
  131. OSErr    CopyFile( inFile, inWD, outFile, outWD )
  132.     char        *inFile;
  133.     short    inWD;
  134.     char        *outFile;
  135.     short    outWD;
  136. /*****************************
  137. * (1) Determine the size of the input 
  138. * file. 
  139. *
  140. * (2) Attempt to allocate that 
  141. * much space for the output file.
  142. *
  143. * (3) If allocation successful,
  144. * create the output file.
  145. *
  146. * (4) Once the file is created,
  147. * copy the data fork, the resource
  148. * fork and the finder information
  149. * from the input file.
  150. * 
  151. * The file will be called "copy of..."
  152. * Each time we create the file, first
  153. * see if that name exists, if so, keep
  154. * sticking "copy of" onto the name.
  155. ******************************/
  156. {
  157.     OSErr    err;
  158.     OSErr    err2;
  159.     short    inref;
  160.     short    outref;
  161.     long        data_eof    = 0L;
  162.     long        rsrc_eof    = 0L;
  163.     FInfo    fndrinfo;
  164.     
  165.     
  166.     /*** (2) Determine how big the input file is ***/
  167.     if( (err = FSOpen( inFile, inWD, &inref )) == noErr){
  168.         err = GetEOF( inref, &data_eof );
  169.         err = FSClose( inref );
  170.     }        
  171.     
  172.     if( (err = OpenRF( inFile, inWD, &inref )) == noErr ){
  173.         err = GetEOF( inref, &rsrc_eof );
  174.         err = FSClose( inref );    
  175.     }
  176.     
  177.     
  178.     /*** (2) Create  output file and allocate space***/
  179.     if( ( err = GetFInfo( inFile, inWD, &fndrinfo ) ) != noErr )
  180.         return( err );
  181.     
  182.     if( ( err = Create( outFile, inWD, fndrinfo.fdCreator, fndrinfo.fdType )) != noErr )
  183.         return( err );
  184.             
  185.     /*** (3) Try to allocate enough space for both***/
  186.     /*** forks. Note that if we get enough space. ***/
  187.         
  188.     if( (err = FSOpen( outFile, outWD, &outref )) != noErr)
  189.         return( err );
  190.     
  191.     if( (err = SetEOF( outref, data_eof  )) != noErr ){
  192.         err2 = FSClose( outref );
  193.         err2 = FSDelete( outFile, outWD );
  194.         return( err );
  195.     }
  196.  
  197.     err2     = FSClose( outref );
  198.     err     = OpenRF( outFile, outWD, &outref );
  199.     
  200.     if( (err = SetEOF( outref, rsrc_eof  )) != noErr ){
  201.         err2 = FSClose( outref );
  202.         err2 = FSDelete( outFile, outWD );
  203.         return( err );
  204.     }
  205.     err2 = FSClose( outref );
  206.  
  207.     
  208.     /*** (4) Copy the Data fork                ***/
  209.     err     = FSOpen( inFile, inWD, &inref );
  210.     
  211.     if( !err ){
  212.         err2     = SetFPos( inref, fsFromStart, 0L );
  213.         err        = CopyFork( inref, outref, data_eof );
  214.         err2     = FSClose( inref );
  215.         err2     = FSClose( outref );    
  216.     }
  217.     
  218.     if( err ){
  219.         err2 = FSDelete( outFile, outWD );
  220.         return( err );
  221.     }
  222.         
  223.     /*** (5) Now copy the resource fork        ***/
  224.     err     = OpenRF( inFile, inWD, &inref );
  225.     
  226.     if( !err ){
  227.         err2     = SetFPos( inref, fsFromStart, 0L );
  228.         err     = OpenRF( outFile, outWD, &outref );
  229.         err        = CopyFork( inref, outref, rsrc_eof );
  230.         err2     = FSClose( inref );
  231.         err2     = FSClose( outref );    
  232.     }
  233.     
  234.     if( err ){
  235.         err2 = FSDelete( outFile, outWD );
  236.         return( err );
  237.     }
  238.         
  239.     return( noErr );
  240. }
  241.  
  242.  
  243.  
  244. LISTING 2: CopyFile and CopyFork Functions.
  245.  
  246.